\documentclass[a4paper,10pt]{report}\input{../0.Préambule/Préambule_cours_prof}\input{0_Préambule_Archi}\begin{document}

\newpage
\setcounter{chapter}{0}
\chapter{Architecture von Neumann}

\section{Un peu d'histoire}

\vspace{-3mm}
En 1946 le premier ordinateur entièrement électronique est enfin opérationnel. Il s'agit de \textbf{l'ENIAC} (Electronic Numerical Integrator And Computer). Il pouvait en principe être reprogrammé pour résoudre tous les problèmes calculatoires (il est dit Turing-complet).

\medskip
Il s'agit d'une machine imposante ($17 468$ tubes à vide, $7 200$ diodes à cristal, $1 500$ relais, $70 000$ résistances, $10 000$ condensateurs et environ 5 millions de soudures faites à la main) occupant une surface de $167$ m$^2$.

\medskip
$6$ femmes ont été les premières personnes à programmer l'ENIAC pour le calcul de tirs balistiques. Pour programmer un calcul il fallait faire un plan des connexions nécessaires, puis procéder au câblage physique. \\Le travail était long et les erreurs dures à détecter.

\section{John von Neumann}

\vspace{-2cm}
\noindent\begin{minipage}{9cm}
\vspace{0.5cm}
\hspace{0.8cm}Le mathématicien/physicien/… américano\\-hongrois John von Neumann (1903 - 1957), qui \\a participé à l'élaboration du projet ENIAC, propose \\alors un nouveau modèle pour simplifier le fonctionnement d'un ordinateur. Il décide de séparer physiquement la partie contrôle/calculs de la partie mémoire, tout en affirmant qu'une instruction n'est qu'une donnée de mémoire comme une autre. C'est le modèle d'architecture de von Neumann, qui est encore utilisé de nos jours !
\end{minipage}
\hspace{-1cm}
\begin{minipage}{8cm}
\begin{center}
\definecolor{qqzzcc}{rgb}{0.,0.6,0.8}
\definecolor{ffffff}{rgb}{1.,1.,1.}
\definecolor{ffzztt}{rgb}{1.,0.6,0.2}
\begin{tikzpicture}[line cap=round,line join=round,>=triangle 45,x=1.0cm,y=1.0cm,scale=0.9]
\clip(1.,1.) rectangle (12.,8.);
\draw[line width=1pt,color=black,fill=white,fill opacity=1.0] (1.,6.) -- (3.,6.) -- (3.,5.) -- (1.,5.) -- cycle;
\draw[line width=1pt,color=black,fill=ffzztt,fill opacity=1.0] (4.,8.) -- (4.,1.) -- (9.,1.) -- (9.,8.) -- cycle;
\draw[line width=1pt,color=black,fill=white,fill opacity=1.0] (10.,6.) -- (10.,5.) -- (12.,5.) -- (12.,6.) -- cycle;
\draw[line width=1pt,color=black,fill=ffffff,fill opacity=1.0] (4.5,7.5) -- (8.5,7.5) -- (8.5,3.5) -- (4.5,3.5) -- cycle;
\draw[line width=1pt,color=black,fill=qqzzcc,fill opacity=1.0] (5.,6.5) -- (5.,5.5) -- (8.,5.5) -- (8.,6.5) -- cycle;
\draw[line width=1pt,color=black,fill=qqzzcc,fill opacity=1.0] (5.,4.) -- (5.,5.) -- (8.,5.) -- (8.,4.) -- cycle;
\draw[line width=1pt,color=black,fill=ffffff,fill opacity=1.0] (4.5,2.5) -- (4.5,1.5) -- (8.5,1.5) -- (8.5,2.5) -- cycle;
\draw [->,line width=1.5pt] (6.,3.5) -- (6.,2.5);
\draw [->,line width=1.5pt] (7.,2.5) -- (7.,3.5);
\draw [->,line width=1.5pt] (3.,5.5) -- (4.,5.5);
\draw [->,line width=1.5pt] (9.,5.5) -- (10.,5.5);
\begin{scriptsize}
\draw[color=black] (2,5.5) node {\textbf{Input device}};
\draw[color=black] (11,5.5) node {\textbf{Output device}};
\draw[color=black] (6.5,7) node {\textbf{Central Processing Unit}};
\draw[color=black] (6.5,6) node {\textbf{Control Unit}};
\draw[color=black] (6.5,4.5) node {\textbf{Aritmetic/Logic Unit}};
\draw[color=black] (6.5,2) node {\textbf{Memory unit}};
\end{scriptsize}
\end{tikzpicture}
\end{center}
\begin{flushright}
\textit{Schéma de l'architecture de von Neumann}
\end{flushright}
\end{minipage}

\vspace{-1.3cm}
\section{Les différentes parties}

\subsection{La mémoire}

Elle permet de stocker des informations sous forme de bits. La mémoire ne peut pas stocker un seul bit à la fois, elle stocke des mots de 8 bits (ou 16/32/64 bits) appelés un octet. Le processeur accède à différents mots de la mémoire grâce à leur adresse.

\subsection{Le processeur (CPU)}
C'est le cœur de tout ordinateur. Il est lui même composé de $2$ parties indépendantes, d'une part l'Unité de Contrôle (UC) et d’autre part l’Unité Arithmétique et Logique (UAL ou ALU en anglais).

\begin{dft}[Unité de contrôle]
Dans un système logique, en particulier dans un processeur, l'unité de contrôle (de commande) ou séquenceur commande et contrôle le fonctionnement du système, notamment du chemin de données. Une unité de contrôle est un circuit logique séquentiel qui réalise un automate fini, qui génère des signaux de contrôle pour piloter les éléments du chemin de données
\end{dft}

\begin{dft}[Unité Arithmétiques et Logique]
L'unité arithmétique et logique est l'organe de l'ordinateur chargé d'effectuer les calculs. Le plus souvent, l'UAL est incluse dans l'unité centrale de traitement ou le microprocesseur. Les UAL élémentaires calculent sur des nombres entiers, et peuvent effectuer les opérations communes, que l'on peut séparer en quatre groupes : les opérations arithmétiques, les opérations logiques, les comparaisons et éventuellement des décalages et rotations.
\end{dft}

\subsection{Les dispositifs d'entrées et de sorties}
Ils permettent d'échanger des informations avec le processeur.

Quelques exemples de dispositifs d'entrées :

\bigskip\dotfill

\bigskip\dotfill

\bigskip\dotfill

Quelques exemples de dispositifs de sorties :

\bigskip\dotfill

\bigskip\dotfill

\bigskip\dotfill

\subsection{Le bus}

C'est la partie physique qui permet aux autres composants de communiquer entre-eux.

\section{Le processeur et ses instructions}

Les UC et UAL d'un processeur ne connaissent qu'un nombre réduit d'instructions. Celles-ci dépendent du modèle et de la marque du processeur mais la plupart des processeurs récents ont une partie de leur jeu d'instructions commune.

\medskip
Afin de pouvoir travailler avec des informations, un processeur possède un petit espace mémoire propre pour stocker des données. Il y a généralement au moins 8 registres permettant de stocker un mot de 8 bits chacun (voir 32 ou même 64 bits pour les plus récents).

\medskip
Il n'est pas demandé en $1^{ère}$ NSI de connaître par cœur le langage assembleur (qui permet de donner presque directement des instructions au processeur) mais vous devez en comprendre le fonctionnement.

\medskip
Voici quelques instructions classiques mais simplifiées pour un microprocesseur ARM moderne :

\begin{center}
\renewcommand{\arraystretch}{1.5}
\begin{tabular}{|>{\centering}m{2cm}|>{\centering}m{2cm}|p{12cm}|}
\hline
Instruction	& Opérandes (exemples) & Commentaires\\\hline
LDR	& R0, 102	& Charge le mot à l'adresse 102 en mémoire dans le registre R0.\\\hline
STR	& R1, 63	& Écrit le contenu du registre R1 dans la mémoire à l'adresse 63.\\\hline
MOV	& R0, R2	& Copie la valeur de R2 dans R0. MOV ne peut pas accéder à la mémoire.\\\hline
ADD	& R0, R3, \# 13	& Ajoute le contenu de R3 et le nombre 13 (opérande immédiat grâce au \#, sinon c’est une adresse mémoire) et écrit le résultat dans le registre R0.\\\hline
SUB	& R1, R2, R0	& Soustrait le contenu de R0 à R2 et écrit le résultat dans R1.\\\hline
B	& 18	& La prochaine instruction se trouve à l'adresse mémoire 18 (saut).\\\hline
CMP	& R0,R1	& \textbf{C}o\textbf{MP}are les valeurs des registres R0 et R1. Commande suivie d'une instruction de saut conditionnel.\\\hline
BEQ	& 13	& En cas d'égalité (\textbf{EQ}ual) du CMP, l'instruction suivante est à l'adresse 13.\\\hline
BNE	& 13	& En cas d'inégalité (\textbf{N}ot \textbf{E}qual) du CMP, ...\\\hline
BGT	& 13	& Si le premier opérande du CMP est supérieur au second (\textbf{G}reater \textbf{T}han), ...\\\hline
BLT	& 13	& Si le premier opérande du CMP est inférieur au second (\textbf{L}ess \textbf{T}han), ...\\\hline
HALT &	 	& Fin de l'exécution. Important sinon le programme continue !\\\hline
\end{tabular}
\end{center}

Vous trouverez \href{http://peterhigginson.co.uk/AQA/}{ici} un simulateur pour processeur ARM.

\begin{ex}
\begin{enumerate}
\item Que font les instructions suivantes ?

\medskip
\begin{minipage}{5cm}
\medskip
MOV R1, \# 33 

\bigskip
ADD R0, R1, \# 12 

\bigskip
STR R0, 100 
\medskip
\end{minipage}
\vline
\hspace{0.5cm}
\begin{minipage}{10.5cm}
\medskip\dotfill 

\bigskip\dotfill 

\bigskip\dotfill 

\end{minipage}

\item Que fait le programme suivant si l'adresse mémoire 102 contient le nombre 42 ?


\hspace{0.5cm}\fbox{\hspace{0.5cm}\begin{minipage}{2.8cm}
\medskip
LDR R0, 102\\
MOV R1, R0\\
ADD R0, R0, R1\\
STR R0, 102
\medskip
\end{minipage}}
\hspace{1.2cm}\vline
\hspace{0.5cm}
\begin{minipage}{10.5cm}
\medskip\dotfill 

\medskip\dotfill 

\medskip\dotfill 

\medskip\dotfill 

\medskip\dotfill
\end{minipage}
\end{enumerate}
\end{ex}

\begin{rmq}
L'assembleur permet aussi d'utiliser des étiquettes pour les adresses mémoires (ce qui est pratique pour les sauts) et se charge de convertir l'étiquette par l'adresse mémoire correspondante.
\end{rmq}

\begin{ex}

\fbox{\begin{minipage}{3.5cm}

\medskip
\hspace{1cm} LDR R0, $30$

\hspace{1cm} LDR R1, $31$

\hspace{1cm} CMP R0, R1

\hspace{1cm} BGT saut

\hspace{1cm} SUB R0, R1, R0

\hspace{1cm} STR R0, $32$

\hspace{1cm} HALT

saut:

\hspace{1cm}SUB R0, R0, R1

\hspace{1cm}STR R0, $32$

\hspace{1cm}HALT
\end{minipage}}
\begin{minipage}{13cm}
\begin{enumerate}
\item Que contient l'adresse mémoire $32$ à la fin du programme si :

\begin{center}
\renewcommand{\arraystretch}{1.5}
\begin{tabular}{|>{\centering}m{3cm}|>{\centering}m{3cm}|m{5cm}|}
\hline
Adresse mémoire 30 au début	& Adresse mémoire 31 & Adresse mémoire 32 à la fin\\\hline
24 & 18	& \\\hline
30 & 45	& \\\hline
12 & 12	& \\\hline
\end{tabular}
\end{center}

\item Que fait donc le programme précédent ? 
\item Écrire un programme en Python faisant la même chose (on considérera que l'adresse mémoire $30$ sera une variable $x$ et l'adresse $31$ une variable $y$).
\end{enumerate}
\end{minipage}
\end{ex}

\textbf{Le défi du chapitre :}

\medskip
Êtes-vous capable d'écrire un programme en assembleur utilisant au maximum $4$ registres pour multiplier un nombre entier positif écrit à l'adresse mémoire $100$ par un nombre entier positif écrit à l'adresse mémoire $101$ et enregistrer le résultat à l'adresse mémoire $102$ ?

\bigskip
Sources : \href{https://fr.wikipedia.org/wiki/Architecture_de_von_Neumann}{Wikipédia : Architecture de von Neumann}

\hspace{1.4cm}\href{https://pixees.fr/informatiquelycee/n_site/nsi_prem_von_neu.html}{Pixees : Ressources pour les sciences numériques}


\end{document}